pub fn shadowing() {
    let c = 1;
    println!("c={}", c);
    let mut c = 2;
    println!("c={}", c);
    c = 3;
    println!("c={}", c);
    // 元组用一对 ( ) 包括的一组数据，可以包含不同种类的数据：
    let c: (i32, f64, bool) = (2, 4.4, false);
    println!("c={}", c.0);
    // 数组用一对 [ ] 包括的同类型数据。
    let c = [1, 2, 3, 4, 5, 6];
    println!("c={}", c[0]);
}

pub fn tuple() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
// tup.0 等于 500
// tup.1 等于 6.4
// tup.2 等于 1
    let (x, y, z) = tup;
// y 等于 6.4
}

pub fn array() {
    let mut a = [1, 2, 3, 4, 5];
// a 是一个长度为 5 的整型数组

    let b = ["January", "February", "March"];
// b 是一个长度为 3 的字符串数组

    let c: [i32; 5] = [1, 2, 3, 4, 5];
// c 是一个长度为 5 的 i32 数组

    let d = [3; 5];
// 等同于 let d = [3, 3, 3, 3, 3];

    let first = a[0];
    let second = a[1];
// 数组访问

    a[0] = 123; // 错误：数组 a 不可变
    let mut a = [1, 2, 3];
    a[0] = 4; // 正确
}

// Rust 函数

// fn <函数名> ( <参数> ) <函数体>

// Rust 中可以在一个用 {} 包括的块里编写一个较为复杂的表达式：
fn basic01() {
    let x = 5;

    let y = {
        let x = 3;
        x + 1
    };

    println!("x 的值为 : {}", x);
    println!("y 的值为 : {}", y);
}

// 这种表达式块是一个合法的函数体。而且在 Rust 中，函数定义可以嵌套：

fn basic02() {
    fn five() -> i32 {
        5
    }
    println!("five() 的值为: {}", five());
}

fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

fn case01() {
    let number = 3;
    if number < 5 {
        println!("条件为 true");
    } else {
        println!("条件为 false");
    }

    let a = 12;
    let b;
    if a > 0 {
        b = 1;
    } else if a < 0 {
        b = -1;
    } else {
        b = 0;
    }
    println!("b is {}", b);


    let a = 3;
    let number = if a > 0 { 1 } else { -1 };
    println!("number 为 {}", number);

    let mut number = 1;
    while number != 4 {
        println!("{}", number);
        number += 1;
    }
    println!("EXIT");


    let mut i = 0;
    while i < 10 {
        // 循环体
        i += 1;
    }

    let a = [10, 20, 30, 40, 50];
    for i in a.iter() {
        println!("值为 : {}", i);
    }

    let a = [10, 20, 30, 40, 50];
    for i in 0..5 {
        println!("a[{}] = {}", i, a[i]);
    }

    let s = ['R', 'U', 'N', 'O', 'O', 'B'];
    let mut i = 0;
    loop {
        let ch = s[i];
        if ch == 'O' {
            break;
        }
        println!("\'{}\'", ch);
        i += 1;
    }

    let s = ['R', 'U', 'N', 'O', 'O', 'B'];
    let mut i = 0;
    let location = loop {
        let ch = s[i];
        if ch == 'O' {
            break i;
        }
        i += 1;
    };
    println!(" \'O\' 的索引为 {}", location);


    // 变量与数据交互方式主要有移动（Move）和克隆（Clone）两种：
}